<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
<link rel="stylesheet" href="../../style.css" type="text/css" media="screen">
<link rel="stylesheet" href="../../print.css" type="text/css" media="print">
<meta content="OverwriteManager,com.greensock.OverwriteManager,ALL_IMMEDIATE,ALL_ONSTART,AUTO,CONCURRENT,NONE,PREEXISTING,mode,init" name="keywords">
<title>com.greensock.OverwriteManager</title>
</head>
<body>
<script type="text/javascript" language="javascript" src="../../asdoc.js"></script><script type="text/javascript" language="javascript" src="../../cookies.js"></script><script type="text/javascript" language="javascript">
<!--
				asdocTitle = 'OverwriteManager - API Documentation';
				var baseRef = '../../';
				window.onload = configPage;
			--></script>
<table style="display:none" id="titleTable" cellspacing="0" cellpadding="0" class="titleTable">
<tr>
<td align="left" class="titleTableTitle">API Documentation</td><td align="right" class="titleTableTopNav"><a onclick="loadClassListFrame('../../all-classes.html')" href="../../package-summary.html">All&nbsp;Packages</a>&nbsp;|&nbsp;<a onclick="loadClassListFrame('../../all-classes.html')" href="../../class-summary.html">All&nbsp;Classes</a>&nbsp;|&nbsp;<a onclick="loadClassListFrame('../../index-list.html')" href="../../all-index-A.html">Index</a>&nbsp;|&nbsp;<a href="../../index.html?com/greensock/OverwriteManager.html&amp;com/greensock/class-list.html" id="framesLink1">Frames</a><a onclick="parent.location=document.location" href="" style="display:none" id="noFramesLink1">No&nbsp;Frames</a></td><td rowspan="3" align="right" class="titleTableLogo"><img alt="Adobe Logo" title="Adobe Logo" class="logoImage" src="../../images/logo.jpg"></td>
</tr>
<tr class="titleTableRow2">
<td align="left" id="subTitle" class="titleTableSubTitle">Class&nbsp;OverwriteManager</td><td align="right" id="subNav" class="titleTableSubNav"><a href="#propertySummary">Properties</a>&nbsp;| <a href="#methodSummary">Methods</a>&nbsp;| <a href="#constantSummary">Constants</a></td>
</tr>
<tr class="titleTableRow3">
<td colspan="2">&nbsp;</td>
</tr>
</table>
<script type="text/javascript" language="javascript">
<!--
if (!isEclipse() || window.name != ECLIPSE_FRAME_NAME) {titleBar_setSubTitle("Class OverwriteManager"); titleBar_setSubNav(true,true,false,false,false,false,true,false,false,false,false,false,false,false);}
--></script>
<div class="MainContent">
<table cellspacing="0" cellpadding="0" class="classHeaderTable">
<tr>
<td class="classHeaderTableLabel">Package</td><td><a onclick="javascript:loadClassListFrame('class-list.html')" href="package-detail.html">com.greensock</a></td>
</tr>
<tr>
<td class="classHeaderTableLabel">Class</td><td class="classSignature">public class OverwriteManager</td>
</tr>
</table>
<p></p>
 OverwriteManager resolves conflicts between tweens and controls if (and how) existing tweens of the same
 target are overwritten. Think of it as a referee or traffic cop for tweens. For example, let's say you have
 a button with <code>ROLL_OVER</code> and <code>ROLL_OUT</code> handlers that tween an object's alpha and the user rolls their mouse
 over/out/over/out quickly. Most likely, you'd want each new tween to overwrite the other immediately so
 that you don't end up with multiple tweens vying for control of the alpha property. That describes
 the <code>ALL_IMMEDIATE</code> mode which is the default mode of TweenLite when it is not used in conjunction with
 TweenMax, TimelineLite, or TimelineMax. This keeps things small and fast. However, it isn't ideal for 
 setting up sequences because as soon as you create subsequent tweens of the same target in the sequence, 
 the previous one gets overwritten. And what if you have a tween that is controling 3 properties and 
 then you create another tween that only controls one of those properties? You may want the first tween 
 to continue tweening the other 2 (non-overlapping) properties. This describes the <code>AUTO</code> mode which is 
 the default whenever TweenMax, TimelineLite, or TimelineMax is used in your swf. OverwriteManager
 offers quite a few other modes to choose from in fact:
 
 <ul>
   <li><b> NONE (0):</b> 
      <ol>
       <li><b>When:</b> Never</li>
       <li><b>Finds:</b> Nothing</li>
       <li><b>Kills:</b> Nothing</li>
       <li><b>Performance:</b> Excellent</li>
       <li><b>Good for:</b> When you know that your tweens won't conflict and you want maximum speed.</li>
      </ol>
   </li>
     
   <li><b> ALL_IMMEDIATE (1):</b> 
      <ol>
       <li><b>When:</b> Immediately when the tween is created.</li>
       <li><b>Finds:</b> All tweens of the same target (regardless of timing or overlapping properties).</li>
       <li><b>Kills:</b> Every tween found</li>
       <li><b>Performance:</b> Excellent</li>
       <li><b>Good for:</b> When you want the tween to take priority over all other tweens of the 
             same target, like on button rollovers/rollouts. However, this mode is 
             bad for setting up sequences.</li>
      </ol>
      This is the default mode for TweenLite unless TweenMax, TimelineLite, 
      or TimelineMax are used in the SWF (in which case <code>AUTO</code> is the default mode).
   </li>
      
   <li><b> AUTO (2):</b> 
      <ol>
       <li><b>When:</b> The first time the tween renders (you can <code>invalidate()</code> a tween to force it 
            to re-init and run its overwriting routine again next time it renders)</li>
       <li><b>Finds:</b> Only tweens of the same target that are active (running). Tweens that haven't started yet are immune.</li>
       <li><b>Kills:</b> Only individual overlapping tweening properties. If all tweening properties 
             have been overwritten, the entire tween will be killed as well.</li>
       <li><b>Performance:</b> Very good when there aren't many overlapping tweens; fair when there are.</li>
       <li><b>Good for:</b> Virtually all situations. This mode does the best job overall of handling 
             overwriting in an intuitive way and is excellent for sequencing. </li>
      </ol>
      This is the default mode when TweenMax, TimelineLite, or TimelineMax is used in your swf (those classes
      automatically init() OverwriteManager in <code>AUTO</code> mode unless you have already initted OverwriteManager manually).
   </li>
      
   <li><b> CONCURRENT (3):</b> 
      <ol>
       <li><b>When:</b> The first time the tween renders (you can <code>invalidate()</code> a tween to force it 
            to re-init and run its overwriting routine again next time it renders)</li>
       <li><b>Finds:</b> Only tweens of the same target that are active (running). Tweens that haven't started yet are immune.</li>
       <li><b>Kills:</b> Every tween found</li>
       <li><b>Performance:</b> Very good</li>
       <li><b>Good for:</b> When you want the target object to only be controled by one tween at a time. Good
             for sequencing although AUTO mode is typically better because it will only kill
             individual overlapping properties instead of entire tweens.</li>
      </ol>
   </li>
     
   <li><b> ALL_ONSTART (4):</b> 
      <ol>
       <li><b>When:</b> The first time the tween renders (you can <code>invalidate()</code> a tween to force it 
            to re-init and run its overwriting routine again next time it renders)</li>
       <li><b>Finds:</b> All tweens of the same target (regardless of timing or overlapping properties).</li>
       <li><b>Kills:</b> Every tween found</li>
       <li><b>Performance:</b> Very good</li>
       <li><b>Good for:</b> When you want a tween to take priority and wipe out all other tweens of the 
             same target even if they start later. This mode is rarely used.</li>
      </ol>
   </li>
 
   <li><b> PREEXISTING (5):</b> 
      <ol>
       <li><b>When:</b> The first time the tween renders (you can <code>invalidate()</code> a tween to force it 
            to re-init and run its overwriting routine again next time it renders)</li>
       <li><b>Finds:</b> Only the tweens of the same target that were created before this tween was created 
             (regardless of timing or overlapping properties). Virtually identical to <code>ALL_IMMEDIATE</code>
             except that <code>PREEXISTING</code> doesn't run its overwriting routines until it renders for the
             first time, meaning that if it has a delay, other tweens won't be overwritten until the delay expires.</li>
       <li><b>Kills:</b> Every tween found</li>
       <li><b>Performance:</b> Very good</li>
       <li><b>Good for:</b> When the order in which your code runs plays a critical role, like when tweens
             that you create later should always take precidence over previously created ones
             regardless of when they're scheduled to run. If <code>ALL_IMMEDIATE</code> is great except
             that you want to wait on overwriting until the tween begins, <code>PREEXISTING</code> is perfect.</li>
      </ol>
   </li>
  </ul>
 
 With the exception of <code>ALL_IMMEDIATE</code> (which performs overwriting immediatly when the tween is created), 
 all overwriting occurs when a tween renders for the first time. So if your tween has a delay of 1 second,
 it will not overwrite any tweens until that point. <br /><br />
 
 You can define a default overwriting mode for all tweens using the <code>OverwriteManager.init()</code> method, like:<br /><br /><code>
 
   OverwriteManager.init(OverwriteManager.AUTO);<br /><br /></code>
 
 If you want to override the default mode in a particular tween, just use the <code>overwrite</code> special 
 property. You can use the static constant or the corresponding number. The following two lines produce 
 the same results:<br /><br /><code>
 
   TweenMax.to(mc, 1, {x:100, overwrite:OverwriteManager.PREXISTING});<br />
   TweenMax.to(mc, 1, {x:100, overwrite:5});<br /><br /></code>
 
 OverwriteManager is a separate, optional class for TweenLite primarily because of file size concerns. 
 Without initting OverwriteManager, TweenLite can only recognize modes 0 and 1 (<code>NONE</code> and <code>ALL_IMMEDIATE</code>). 
 However, TweenMax, TimelineLite, and TimelineMax automatically init() OverwriteManager in <code>AUTO</code> mode 
 unless you have already initted OverwriteManager manually. You do not need to take any additional steps
 to use AUTO mode if you're using any of those classes somewhere in your project. Keep in mind too that setting 
 the default OverwriteManager mode will affect TweenLite and TweenMax tweens.<br /><br />
   
 
 <b>EXAMPLES:</b><br /><br /> 
 
  To start OverwriteManager in <code>AUTO</code> mode (the default) and then do a simple TweenLite tween, simply do:<br /><br /><code>
   
   import com.greensock.OverwriteManager;<br />
   import com.greensock.TweenLite;<br /><br />
   
   OverwriteManager.init(OverwriteManager.AUTO);<br />
   TweenLite.to(mc, 2, {x:300});<br /><br /></code>
   
  You can also define overwrite behavior in individual tweens, like so:<br /><br /><code>
  
   import com.greensock.OverwriteManager;<br />
   import com.greensock.TweenLite;<br /><br />
   
   OverwriteManager.init(2);<br />
   TweenLite.to(mc, 2, {x:"300", y:"100"});<br />
   TweenLite.to(mc, 1, {alpha:0.5, overwrite:1}); //or use the constant OverwriteManager.ALL_IMMEDIATE<br />
   TweenLite.to(mc, 3, {x:200, rotation:30, overwrite:2}); //or use the constant OverwriteManager.AUTO<br /><br /></code>
   
   
  OverwriteManager's mode can be changed anytime after init() is called, like.<br /><br /><code>
   
   OverwriteManager.mode = OverwriteManager.CONCURRENT;<br /><br /></code>
 
 <b>Copyright 2009, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
 
 <p></p>
<br>
<hr>
</div>
<a name="propertySummary"></a>
<div class="summarySection">
<div class="summaryTableTitle">Public Properties</div>
<table id="summaryTableProperty" class="summaryTable " cellpadding="3" cellspacing="0">
<tr>
<th>&nbsp;</th><th colspan="2">Property</th><th class="summaryTableOwnerCol">Defined&nbsp;by</th>
</tr>
<tr class="">
<td class="summaryTablePaddingCol">&nbsp;</td><td class="summaryTableInheritanceCol">&nbsp;</td><td class="summaryTableSignatureCol"><a class="signatureLink" href="#mode">mode</a> : int<div class="summaryTableDescription">[static] The default overwrite mode for all TweenLite and TweenMax instances </div>
</td><td class="summaryTableOwnerCol">OverwriteManager</td>
</tr>
</table>
</div>
<a name="methodSummary"></a>
<div class="summarySection">
<div class="summaryTableTitle">Public Methods</div>
<table id="summaryTableMethod" class="summaryTable " cellpadding="3" cellspacing="0">
<tr>
<th>&nbsp;</th><th colspan="2">Method</th><th class="summaryTableOwnerCol">Defined&nbsp;by</th>
</tr>
<tr class="">
<td class="summaryTablePaddingCol">&nbsp;</td><td class="summaryTableInheritanceCol">&nbsp;</td><td class="summaryTableSignatureCol">
<div class="summarySignature">
<a class="signatureLink" href="#init()">init</a>(defaultMode:int = 2):int</div>
<div class="summaryTableDescription">[static] 
   Initializes OverwriteManager and sets the default management mode.</div>
</td><td class="summaryTableOwnerCol">OverwriteManager</td>
</tr>
</table>
</div>
<a name="constantSummary"></a>
<div class="summarySection">
<div class="summaryTableTitle">Public Constants</div>
<table id="summaryTableConstant" class="summaryTable " cellpadding="3" cellspacing="0">
<tr>
<th>&nbsp;</th><th colspan="2">Constant</th><th class="summaryTableOwnerCol">Defined&nbsp;by</th>
</tr>
<tr class="">
<td class="summaryTablePaddingCol">&nbsp;</td><td class="summaryTableInheritanceCol">&nbsp;</td><td class="summaryTableSignatureCol"><a class="signatureLink" href="#ALL_IMMEDIATE">ALL_IMMEDIATE</a> : int = 1<div class="summaryTableDescription">[static] Overwrites all existing tweens of the same target immediately when the tween is created </div>
</td><td class="summaryTableOwnerCol">OverwriteManager</td>
</tr>
<tr class="">
<td class="summaryTablePaddingCol">&nbsp;</td><td class="summaryTableInheritanceCol">&nbsp;</td><td class="summaryTableSignatureCol"><a class="signatureLink" href="#ALL_ONSTART">ALL_ONSTART</a> : int = 4<div class="summaryTableDescription">[static] Overwrites all tweens of the same target (regardless of overlapping properties or timing) when the tween renders for the first time as opposed to ALL_IMMEDIATE which performs overwriting immediately when the tween is created.</div>
</td><td class="summaryTableOwnerCol">OverwriteManager</td>
</tr>
<tr class="">
<td class="summaryTablePaddingCol">&nbsp;</td><td class="summaryTableInheritanceCol">&nbsp;</td><td class="summaryTableSignatureCol"><a class="signatureLink" href="#AUTO">AUTO</a> : int = 2<div class="summaryTableDescription">[static] Only overwrites individual overlapping tweening properties in other tweens of the same target.</div>
</td><td class="summaryTableOwnerCol">OverwriteManager</td>
</tr>
<tr class="">
<td class="summaryTablePaddingCol">&nbsp;</td><td class="summaryTableInheritanceCol">&nbsp;</td><td class="summaryTableSignatureCol"><a class="signatureLink" href="#CONCURRENT">CONCURRENT</a> : int = 3<div class="summaryTableDescription">[static] Overwrites tweens of the same target that are active when the tween renders for the first time.</div>
</td><td class="summaryTableOwnerCol">OverwriteManager</td>
</tr>
<tr class="">
<td class="summaryTablePaddingCol">&nbsp;</td><td class="summaryTableInheritanceCol">&nbsp;</td><td class="summaryTableSignatureCol"><a class="signatureLink" href="#NONE">NONE</a> : int = 0<div class="summaryTableDescription">[static] Won't overwrite any other tweens </div>
</td><td class="summaryTableOwnerCol">OverwriteManager</td>
</tr>
<tr class="">
<td class="summaryTablePaddingCol">&nbsp;</td><td class="summaryTableInheritanceCol">&nbsp;</td><td class="summaryTableSignatureCol"><a class="signatureLink" href="#PREEXISTING">PREEXISTING</a> : int = 5<div class="summaryTableDescription">[static] Overwrites tweens of the same target that existed before this tween regardless of their start/end time or active state or overlapping properties.</div>
</td><td class="summaryTableOwnerCol">OverwriteManager</td>
</tr>
</table>
</div>
<script type="text/javascript" language="javascript">
<!--
showHideInherited();
--></script>
<div class="MainContent">
<a name="propertyDetail"></a>
<div class="detailSectionHeader">Property detail</div>
<a name="mode"></a>
<table cellspacing="0" cellpadding="0" class="detailHeader">
<tr>
<td class="detailHeaderName">mode</td><td class="detailHeaderType">property</td>
</tr>
</table>
<div class="detailBody">
<code>public static var mode:int</code><p> The default overwrite mode for all TweenLite and TweenMax instances </p></div>
<a name="methodDetail"></a>
<div class="detailSectionHeader">Method detail</div>
<a name="init()"></a>
<table cellspacing="0" cellpadding="0" class="detailHeader">
<tr>
<td class="detailHeaderName">init</td><td class="detailHeaderParens">()</td><td class="detailHeaderType">method</td>
</tr>
</table>
<div class="detailBody">
<code>public static function init(defaultMode:int = 2):int</code><p> 
   Initializes OverwriteManager and sets the default management mode. Options include: 
   <ul>
     <li><b> NONE (0):</b> 
        <ol>
         <li><b>When:</b> Never</li>
         <li><b>Finds:</b> Nothing</li>
         <li><b>Kills:</b> Nothing</li>
         <li><b>Performance:</b> Excellent</li>
         <li><b>Good for:</b> When you know that your tweens won't conflict and you want maximum speed.</li>
        </ol>
     </li>
       
     <li><b> ALL_IMMEDIATE (1):</b> 
        <ol>
         <li><b>When:</b> Immediately when the tween is created.</li>
         <li><b>Finds:</b> All tweens of the same target (regardless of timing or overlapping properties).</li>
         <li><b>Kills:</b> Every tween found</li>
         <li><b>Performance:</b> Excellent</li>
         <li><b>Good for:</b> When you want the tween to take priority over all other tweens of the 
               same target, like on button rollovers/rollouts. However, this mode is 
               bad for setting up sequences.</li>
        </ol>
        This is the default mode for TweenLite unless TweenMax, TimelineLite, 
        or TimelineMax are used in the SWF (in which case <code>AUTO</code> is the default mode).
     </li>
        
     <li><b> AUTO (2):</b> 
        <ol>
         <li><b>When:</b> The first time the tween renders (you can <code>invalidate()</code> a tween to force it 
              to re-init and run its overwriting routine again next time it renders)</li>
         <li><b>Finds:</b> Only tweens of the same target that are active (running). Tweens that haven't started yet are immune.</li>
         <li><b>Kills:</b> Only individual overlapping tweening properties. If all tweening properties 
               have been overwritten, the entire tween will be killed as well.</li>
         <li><b>Performance:</b> Very good when there aren't many overlapping tweens; fair when there are.</li>
         <li><b>Good for:</b> Virtually all situations. This mode does the best job overall of handling 
               overwriting in an intuitive way and is excellent for sequencing. </li>
        </ol>
        This is the default mode when TweenMax, TimelineLite, or TimelineMax is used in your swf (those classes
        automatically init() OverwriteManager in <code>AUTO</code> mode unless you have already initted OverwriteManager manually).
     </li>
        
     <li><b> CONCURRENT (3):</b> 
        <ol>
         <li><b>When:</b> The first time the tween renders (you can <code>invalidate()</code> a tween to force it 
              to re-init and run its overwriting routine again next time it renders)</li>
         <li><b>Finds:</b> Only tweens of the same target that are active (running). Tweens that haven't started yet are immune.</li>
         <li><b>Kills:</b> Every tween found</li>
         <li><b>Performance:</b> Very good</li>
         <li><b>Good for:</b> When you want the target object to only be controled by one tween at a time. Good
               for sequencing although AUTO mode is typically better because it will only kill
               individual overlapping properties instead of entire tweens.</li>
        </ol>
     </li>
       
     <li><b> ALL_ONSTART (4):</b> 
        <ol>
         <li><b>When:</b> The first time the tween renders (you can <code>invalidate()</code> a tween to force it 
              to re-init and run its overwriting routine again next time it renders)</li>
         <li><b>Finds:</b> All tweens of the same target (regardless of timing or overlapping properties).</li>
         <li><b>Kills:</b> Every tween found</li>
         <li><b>Performance:</b> Very good</li>
         <li><b>Good for:</b> When you want a tween to take priority and wipe out all other tweens of the 
               same target even if they start later. This mode is rarely used.</li>
        </ol>
     </li>
   
     <li><b> PREEXISTING (5):</b> 
        <ol>
         <li><b>When:</b> The first time the tween renders (you can <code>invalidate()</code> a tween to force it 
              to re-init and run its overwriting routine again next time it renders)</li>
         <li><b>Finds:</b> Only the tweens of the same target that were created before this tween was created 
               (regardless of timing or overlapping properties). Virtually identical to <code>ALL_IMMEDIATE</code>
               except that <code>PREEXISTING</code> doesn't run its overwriting routines until it renders for the
               first time, meaning that if it has a delay, other tweens won't be overwritten until the delay expires.</li>
         <li><b>Kills:</b> Every tween found</li>
         <li><b>Performance:</b> Very good</li>
         <li><b>Good for:</b> When the order in which your code runs plays a critical role, like when tweens
               that you create later should always take precidence over previously created ones
               regardless of when they're scheduled to run. If <code>ALL_IMMEDIATE</code> is great except
               that you want to wait on overwriting until the tween begins, <code>PREEXISTING</code> is perfect.</li>
        </ol>
     </li>
    </ul>
   
   </p><span class="label">Parameters</span>
<table border="0" cellspacing="0" cellpadding="0">
<tr>
<td width="20px"></td><td><code><span class="label">defaultMode</span>:int</code> (default = <code>2</code>)<code></code> &mdash; The default mode that OverwriteManager should use.
   </td>
</tr>
</table>
<p></p>
<span class="label">Returns</span>
<table border="0" cellspacing="0" cellpadding="0">
<tr>
<td width="20"></td><td><code>int</code></td>
</tr>
</table>
</div>
<a name="constantDetail"></a>
<div class="detailSectionHeader">Constant detail</div>
<a name="ALL_IMMEDIATE"></a>
<table cellspacing="0" cellpadding="0" class="detailHeader">
<tr>
<td class="detailHeaderName">ALL_IMMEDIATE</td><td class="detailHeaderType">constant</td>
</tr>
</table>
<div class="detailBody">
<code>public static const ALL_IMMEDIATE:int = 1</code><p> Overwrites all existing tweens of the same target immediately when the tween is created </p></div>
<a name="ALL_ONSTART"></a>
<table cellspacing="0" cellpadding="0" class="detailHeader">
<tr>
<td class="detailHeaderName">ALL_ONSTART</td><td class="detailHeaderType">constant</td><td class="detailHeaderRule">&nbsp;</td>
</tr>
</table>
<div class="detailBody">
<code>public static const ALL_ONSTART:int = 4</code><p> Overwrites all tweens of the same target (regardless of overlapping properties or timing) when the tween renders for the first time as opposed to ALL_IMMEDIATE which performs overwriting immediately when the tween is created. </p></div>
<a name="AUTO"></a>
<table cellspacing="0" cellpadding="0" class="detailHeader">
<tr>
<td class="detailHeaderName">AUTO</td><td class="detailHeaderType">constant</td><td class="detailHeaderRule">&nbsp;</td>
</tr>
</table>
<div class="detailBody">
<code>public static const AUTO:int = 2</code><p> Only overwrites individual overlapping tweening properties in other tweens of the same target. TweenMax, TimelineLite, and TimelineMax automatically init() OverwriteManager in this mode if you haven't already called OverwriteManager.init(). </p></div>
<a name="CONCURRENT"></a>
<table cellspacing="0" cellpadding="0" class="detailHeader">
<tr>
<td class="detailHeaderName">CONCURRENT</td><td class="detailHeaderType">constant</td><td class="detailHeaderRule">&nbsp;</td>
</tr>
</table>
<div class="detailBody">
<code>public static const CONCURRENT:int = 3</code><p> Overwrites tweens of the same target that are active when the tween renders for the first time. </p></div>
<a name="NONE"></a>
<table cellspacing="0" cellpadding="0" class="detailHeader">
<tr>
<td class="detailHeaderName">NONE</td><td class="detailHeaderType">constant</td><td class="detailHeaderRule">&nbsp;</td>
</tr>
</table>
<div class="detailBody">
<code>public static const NONE:int = 0</code><p> Won't overwrite any other tweens </p></div>
<a name="PREEXISTING"></a>
<table cellspacing="0" cellpadding="0" class="detailHeader">
<tr>
<td class="detailHeaderName">PREEXISTING</td><td class="detailHeaderType">constant</td><td class="detailHeaderRule">&nbsp;</td>
</tr>
</table>
<div class="detailBody">
<code>public static const PREEXISTING:int = 5</code><p> Overwrites tweens of the same target that existed before this tween regardless of their start/end time or active state or overlapping properties. </p></div>
<br>
<br>
<hr>
<br>
<p></p>
<center class="copyright"> 
</center>
</div>
</body>
</html>
<!-- -->
